home *** CD-ROM | disk | FTP | other *** search
/ Scene Storm / Scene Storm - Volume 1.iso / coding / c / lha_axeman / util.c < prev   
C/C++ Source or Header  |  1995-09-01  |  7KB  |  351 lines
  1. /*
  2.  * util.c - part of LHa for UNIX
  3.  *    Feb 26 1992 modified by Masaru Oki
  4.  *    Mar  4 1992 modified by Masaru Oki
  5.  *        #ifndef USESTRCASECMP added.
  6.  *    Mar 31 1992 modified by Masaru Oki
  7.  *        #ifdef NOMEMSET added.
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include <errno.h>
  12. #ifdef sony_news
  13. #include <sys/param.h>
  14. #endif
  15. #if defined(__STDC__) || defined(NEWSOS)
  16. #include <stdlib.h>
  17. #endif
  18. #include "lharc.h"
  19.  
  20. #define BUFFERSIZE 2048
  21. #ifndef NULL
  22. #define NULL (char *)0
  23. #endif
  24.  
  25. extern unsigned short crc;
  26. extern int quiet;
  27.  
  28. long copyfile(f1, f2, size, crc_flg)    /* return: size of source file */
  29. FILE *f1;
  30. FILE *f2;
  31. long size;
  32. int crc_flg;    /* 0: no crc, 1: crc check, 2: extract, 3: append */
  33. {
  34.     unsigned short xsize;
  35.     char *buf;
  36.     long rsize = 0;
  37.  
  38.     if ((buf = (char *)malloc(BUFFERSIZE)) == NULL)
  39.         fatal_error("virtual memory exhausted.\n");
  40.     crc = 0;
  41.     if ((crc_flg == 2 || crc_flg) && text_mode)
  42.         init_code_cache();
  43.     while (size > 0) {
  44.         /* read */
  45.         if (crc_flg == 3 && text_mode) {
  46.             xsize = fread_txt(buf, BUFFERSIZE, f1);
  47.             if (xsize == 0)
  48.                 break;
  49.             if (ferror(f1)) {
  50.                 fatal_error("file read error\n");
  51.             }
  52.         }
  53.         else {
  54.             xsize = (size > BUFFERSIZE) ? BUFFERSIZE : size;
  55.             if (fread(buf, 1, xsize, f1) != xsize) {
  56.                 fatal_error("file read error\n");
  57.             }
  58.         }
  59.         /* write */
  60.         if (f2) {
  61.             if (crc_flg == 2 && text_mode) {
  62.                 if (fwrite_txt(buf, xsize, f2)) {
  63.                     fatal_error("file write error\n");
  64.                 }
  65.             }
  66.             else {
  67.                 if (fwrite(buf, 1, xsize, f2) != xsize) {
  68.                     fatal_error("file write error\n");
  69.                 }
  70.             }
  71.         }
  72.         /* calculate crc */
  73.         if (crc_flg) {
  74.             calccrc(buf, xsize);
  75.         }
  76.         rsize += xsize;
  77.         if (crc_flg != 3 || !text_mode)
  78.             size -= xsize;
  79.     }
  80.     free(buf);
  81.     return rsize;
  82. }
  83.  
  84. int
  85. encode_stored_crc (ifp, ofp, size, original_size_var, write_size_var)
  86. FILE *ifp, *ofp;
  87. long size;
  88. long *original_size_var;
  89. long *write_size_var;
  90. {
  91.     int save_quiet;
  92.  
  93.     save_quiet = quiet;
  94.     quiet = 1;
  95.     size = copyfile (ifp,ofp,size,3);
  96.     *original_size_var = *write_size_var = size;
  97.     quiet = save_quiet;
  98.     return crc;
  99. }
  100.  
  101. /***************************************
  102.     convert path delimiter
  103. ****************************************
  104.     returns *filename
  105. ***************************************/
  106. unsigned char *
  107. convdelim(path, delim)
  108. unsigned char *path;
  109. unsigned char delim;
  110. {
  111.   unsigned char c;
  112.   unsigned char *p;
  113. #ifdef MULTIBYTE_CHAR
  114.   int kflg;
  115.  
  116.   kflg = 0;
  117. #endif
  118.   for (p = path; (c = *p) != 0; p++) {
  119. #ifdef MULTIBYTE_CHAR
  120.     if (kflg) {
  121.       kflg = 0;
  122.     } else if (iskanji(c)) {
  123.       kflg = 1;
  124.     } else
  125. #endif
  126.       if (c == '\\' || c == DELIM || c == DELIM2)
  127.     {
  128.       *p = delim;
  129.       path = p + 1;
  130.     }
  131.   }
  132.   return path;
  133. }
  134.  
  135. /* If TRUE, archive file name is msdos SFX file name. */
  136. boolean
  137. archive_is_msdos_sfx1 (name)
  138.      char *name;
  139. {
  140.   int len = strlen (name);
  141.  
  142.   return ((len >= 4) &&
  143.       (strucmp (".COM",name + len - 4) == 0 ||
  144.        strucmp (".EXE",name + len - 4) == 0)) ||
  145.      ((len >= 2) &&
  146.       (strucmp (".x",name + len - 2) == 0));
  147. }
  148.  
  149. /* skip SFX header */
  150. boolean
  151. skip_msdos_sfx1_code (fp)
  152.      FILE *fp;
  153. {
  154.   unsigned char buffer[4096];
  155.   unsigned char *p, *q;
  156.   int n;
  157.  
  158.   n = fread (buffer, sizeof (char), 4096, fp);
  159.  
  160.   for (p = buffer + 2, q = buffer + n - 5; p < q; p ++)
  161.     {
  162.       /* found "-l??-" keyword (as METHOD type string) */
  163.       if (p[0] == '-' && p[1] == 'l' && p[4] == '-')
  164.     {
  165.       /* size and checksum validate check */
  166.       if (p[-2] > 20 && p[-1] == calc_sum (p, p[-2]))
  167.         {
  168.           fseek (fp, ((p - 2) - buffer) - n, SEEK_CUR);
  169.           return TRUE;
  170.         }
  171.     }
  172.     }
  173.  
  174.   fseek (fp, -n, SEEK_CUR);
  175.   return FALSE;
  176. }
  177.  
  178. /*
  179.  * strdup(3)
  180.  */
  181.  
  182. #ifdef NOSTRDUP
  183. char *strdup ( buf )
  184. char *buf;
  185. {
  186.     char *p;
  187.  
  188.     if ((p = (char *)malloc(strlen(buf) + 1)) == NULL) return NULL;
  189.     strcpy( p, buf );
  190.     return p;
  191. }
  192. #endif
  193.  
  194. /*
  195.  *    memmove( char *dst , char *src , size_t cnt )
  196.  */
  197.  
  198. #if defined(NOBSTRING) && !defined(__STDC__)
  199. void *
  200. memmove( dst , src , cnt )
  201. register char *dst , *src;
  202. register int cnt;
  203. {
  204.     if ( dst == src ) return dst;
  205.     if ( src > dst )
  206.     {
  207.         while ( --cnt >=0 ) *dst++ = *src++;
  208.     }
  209.     else
  210.     {
  211.         dst += cnt; src += cnt;
  212.         while ( --cnt >=0 ) *--dst = *--src;
  213.     }
  214.     return dst;
  215. }
  216. #endif
  217.  
  218. /* rename - change the name of file
  219.  * 91.11.02 by Tomohiro Ishikawa (ishikawa@gaia.cow.melco.CO.JP)
  220.  * 92.01.20 little modified (added #ifdef) by Masaru Oki
  221.  * 92.01.28 added mkdir() and rmdir() by Tomohiro Ishikawa
  222.  */
  223.  
  224. #if defined(NOFTRUNCATE) && !defined(_MINIX)
  225.  
  226. int
  227. rename(from, to)
  228. char *from, *to;
  229. {
  230.     struct    stat s1,s2;
  231.     extern    int errno;
  232.  
  233.     if (stat(from, &s1) < 0)
  234.         return(-1);
  235.         /* is 'FROM' file a directory? */
  236.     if ((s1.st_mode & S_IFMT) == S_IFDIR){
  237.         errno = ENOTDIR;
  238.         return(-1);
  239.     }
  240.     if (stat(to, &s2) >= 0) { /* 'TO' exists! */
  241.         /* is 'TO' file a directory? */
  242.         if ((s2.st_mode & S_IFMT) == S_IFDIR){
  243.             errno=EISDIR;
  244.             return(-1);
  245.         }
  246.         if (unlink(to) < 0)
  247.             return(-1);
  248.     }
  249.     if (link(from, to) < 0)
  250.         return(-1);
  251.     if (unlink(from) < 0)
  252.         return(-1);
  253.     return(0);
  254. }
  255. #endif /* NOFTRUNCATE */
  256.  
  257. #ifdef    NOMKDIR
  258. #ifndef    MKDIRPATH
  259. #define    MKDIRPATH    "/bin/mkdir"
  260. #endif
  261. #ifndef    RMDIRPATH
  262. #define    RMDIRPATH    "/bin/rmdir"
  263. #endif
  264. int
  265. rmdir(path)
  266. char *path;
  267. {
  268.     int    stat,rtn=0;
  269.     char    *cmdname;
  270.     if ( (cmdname=(char *)malloc(strlen(RMDIRPATH)+1+strlen(path)+1))
  271.         == 0)
  272.         return(-1);
  273.     strcpy(cmdname,RMDIRPATH);
  274.     *(cmdname+strlen(RMDIRPATH))=' ';
  275.     strcpy(cmdname+strlen(RMDIRPATH)+1,path);
  276.     if ((stat = system(cmdname))<0)
  277.         rtn=-1;    /* fork or exec error */
  278.     else if(stat){        /* RMDIR command error */
  279.         errno = EIO;
  280.         rtn=-1;
  281.     }
  282.     free(cmdname);
  283.     return(rtn);
  284. }
  285. int
  286. mkdir(path,mode)
  287. char    *path;
  288. int    mode;
  289. {
  290.     int child, stat;
  291.     char    *cmdname,*cmdpath=MKDIRPATH;
  292.     if ( (cmdname=(char *)strrchr(cmdpath,'/'))==(char *)0)
  293.         cmdname=cmdpath;
  294.     if ((child = fork())<0)
  295.         return(-1);    /* fork error */
  296.     else if(child) {    /* parent process */
  297.         while (child != wait(&stat))    /* ignore signals */
  298.             continue;
  299.     }
  300.     else{            /* child process */
  301.         int    maskvalue;
  302.         maskvalue = umask(0);    /* get current umask() value */
  303.         umask(maskvalue | (0777 & ~mode)); /* set it! */
  304.         execl(cmdpath, cmdname, path, (char *)0);
  305.         /* never come here except execl is error */
  306.         return(-1);
  307.     }
  308.     if (stat != 0) {
  309.         errno = EIO;    /* cannot get error num. */
  310.         return(-1);
  311.     }
  312.     return(0);
  313. }
  314. #endif
  315.  
  316. /*
  317.  * strucmp
  318.  *    modified: Oct 29 1991 by Masaru Oki
  319.  */
  320.  
  321. #ifndef USESTRCASECMP
  322. static int my_toupper(n)
  323.   register int n;
  324. {
  325.   if(n >= 'a' && n <= 'z') return n & (~('a'-'A'));
  326.   return n;
  327. }
  328.  
  329. int strucmp(s, t)
  330. register char *s, *t;
  331. {
  332.     while (my_toupper(*s++) == my_toupper(*t++))
  333.         if ( !*s || !*t ) break;
  334.     if ( !*s && !*t ) return 0;
  335.     return 1;
  336. }
  337. #endif
  338.  
  339. #ifdef NOMEMSET
  340. /* Public Domain memset(3) */
  341. char *
  342. memset (s, c, n)
  343. char *s;
  344. int c, n;
  345. {
  346.   char *p = s;
  347.   while(n--) *p++ = (char)c;
  348.   return s;
  349. }
  350. #endif
  351.